SOLID é um acrônimo para um grupo de cinco bons princípios (regras) em programação de computadores. SOLID permite que os programadores escrevam código que seja mais fácil de entender e alterar posteriormente. SOLID é frequentemente usado com sistemas que usam um design orientado a objetos.
Vamos explicar os princípios do SOLID usando o exemplo do veículo. Imagine que estamos projetando um sistema para gerenciar diferentes tipos de veículos, como carros e carros elétricos, para um serviço de transporte.

S - Princípio de Responsabilidade Única (SRP)

Exemplo de veículo: Imagine que você tem um carro. É responsável por dirigir, mas não deveria ser responsável por cuidar de sua própria manutenção (como trocas de óleo ou rotação de pneus). Em vez disso, um mecânico separado é responsável por isso.
Explicação: Em nosso código, a classe Vehicle deve lidar apenas com coisas relacionadas ao próprio veículo, como armazenar sua marca e modelo. Se precisarmos gerenciar a manutenção, criamos uma classe Maintenance separada para isso. Dessa forma, cada classe tem uma função ou responsabilidade, facilitando o gerenciamento do código.

class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end
end

class Maintenance
  def initialize(vehicle)
    @vehicle = vehicle
  end

  def perform_maintenance
    puts "Performing maintenance on #{@vehicle.make} #{@vehicle.model}"
  end
end

Princípio O - Aberto/Fechado (OCP)

Exemplo de veículo: Suponha que você tenha um carro básico e agora queira adicionar um carro elétrico ao seu sistema. Você não deveria ter que modificar a classe de carro existente para adicionar recursos para carros elétricos. Em vez disso, você pode estender a funcionalidade existente criando uma nova classe para carros elétricos.
Explicação: A classe Vehicle está aberta para extensão (você pode criar novos tipos de veículos como ElectricVehicle), mas está fechada para modificação (você não precisa alterar a classe Vehicle em si para adicionar novos tipos).

class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end

  def description
    "#{@make} #{@model}"
  end
end

class ElectricVehicle 





  
  
  Princípio de Substituição L - Liskov (LSP)


Exemplo de veículo: Imagine que você tem uma frota de veículos e pode substituir qualquer carro normal por um carro elétrico sem problemas. Ambos devem ser capazes de executar sua função básica - dirigir - sem quebrar o sistema.

Explicação: Qualquer subclasse (como ElectricVehicle) deve ser capaz de substituir sua classe pai (Vehicle) sem alterar o comportamento do programa. Isso garante que nosso código possa lidar com diferentes tipos de veículos da mesma maneira.

classe Veículo
  def inicializar(marca, modelo)
    @fazer = fazer
    @modelo = modelo
  fim

  unidade de definição
    coloca "Dirigindo o #{@make} #{@model}"
  fim
fim

classe Veículo Elétrico class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end

  def drive
    puts "Driving the #{@make} #{@model}"
  end
end

class ElectricVehicle 


  
  
  Princípio de segregação de interface I - (ISP)


Exemplo de veículo: Imagine que você tem diferentes tipos de veículos: alguns podem ser carregados (como carros elétricos) e outros só podem ser dirigidos (como carros a gasolina). Você não quer que um carro a gasolina tenha que lidar com métodos relacionados à cobrança.

Explicação: As classes devem implementar apenas as interfaces (ou comportamentos) de que precisam. Por exemplo, um Veículo Elétrico pode implementar interfaces Dirigíveis e Carregáveis, enquanto um Veículo normal implementa apenas Dirigíveis.

módulo dirigível
  unidade de definição
    raise NotImplementedError, "Este #{self.class} não pode ser conduzido"
  fim
fim

módulo carregável
  cobrança definitiva
    raise NotImplementedError, "Este #{self.class} não pode ser cobrado"
  fim
fim

classe Veículo
  incluir dirigível

  def inicializar(marca, modelo)
    @fazer = fazer
    @modelo = modelo
  fim

  unidade de definição
    coloca "Dirigindo o #{@make} #{@model}"
  fim
fim

classe Veículo Elétrico class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end

  def drive
    puts "Driving the #{@make} #{@model}"
  end
end

class ElectricVehicle 


  
  
  Princípio de Inversão de Dependência D - (DIP)


Exemplo de veículo: Imagine que um carro pode ter diferentes tipos de motores: um motor a gasolina ou um motor elétrico. Em vez de depender diretamente de um tipo de motor específico, o carro deve depender de uma interface de motor mais geral para poder usar qualquer tipo de motor.

Explicação: Módulos de alto nível (como o Veículo) não devem depender de módulos de baixo nível (como GasEngine ou ElectricEngine). Ambos devem depender de abstrações (como uma interface Engine). Isso torna o sistema mais flexível e mais fácil de mudar.

motor de classe
  definitivamente começar
    raise NotImplementedError, "Este #{self.class} não pode ser iniciado"
  fim
fim

class GasEngine class Engine
  def start
    raise NotImplementedError, "This #{self.class} cannot start"
  end
end

class GasEngine Seguindo os princípios SOLID neste exemplo de veículo, podemos construir um sistema que seja fácil de manter, ampliar e adaptar a novos requisitos.


LinkedIn: https://www.linkedin.com/in/anandsoni11/